$(function () {
    // 全局接口返回物料基本信息
    let globalBaseInfo = null
    // 全局总流程数据(父节点即子阶段，子节点即活动节点)
    let processData = null
    // 工作项目列表数据(添加子阶段节点时)
    let projectList = null
    // 工作要素列表数据(添加活动节点时)
    let elementList = null
    // 当前添加节点按钮类型 (NODE_TYPE_PARENT, NODE_TYPE_CHILD)
    let currentAddNodeType = '' 
    // 当前添加节点 tab 点击的 id （"tabs-project", "tabs-custom"）
    let currentAddNodeTabIndex = 'tabs-project'
    // 添加节点弹窗
    let addNodeDialog = null
    // 编辑节点弹窗
    let editNodeDialog = null
    // 删除节点弹窗
    let deleteNodeDialog = null
    // 全局变量，用于存储新子节点的父节点
    let pendingAddChildParent = null
    // 全局变量，编辑父节点时存储当前正在编辑的父节点
    let currentEditingParent = null
    // 全局变量，编辑子节点时存储当前正在编辑的子节点
    let currentEditingChild = null
    // 全局变量，删除父节点时存储当前正在删除的父节点
    let pendingDeleteParent = null
    // 全局变量，删除子节点时存储当前正在删除的子节点
    let pendingDeleteChild = null

    // 查看详情地址
    let detailUrl = `./w?sid=${sid}&cmd=com.awspaas.user.apps.model_FLOW_DESIGNER_PROPERTIES_PAGE&propertyType=useTask`
    // 差异比对地址
    let compareUrl = `./w?sid=${sid}&cmd=com.awspaas.user.apps.pdc_FLOW_COMPARE_LOOKBOARD`

    // 添加节点 操作类型
    const NODE_TYPE_PARENT = "parentNode"
    const NODE_TYPE_CHILD = "childNode"

    // 状态
    const statusOptions = {
        0: { label: "策划中"},
        1: { label: "未采集"},
        2: { label: "采集中"},
        3: { label: "已完成"},
        4: { label: "异常"},
    }

    init()
    
    // 初始化页面
    function init() {
        apiUtil.getAllProcessData().then((res)=> {
            if(res.result === "ok" && res.data) {
                // 物料基本信息
                globalBaseInfo = res.data.baseInfo
                // 流程树数据
                processData = res.data?.processData || []

                // 模型名称
                $("#materialName").html(res.data?.baseInfo?.materialName || '')
                $("head>title").html(res.data?.baseInfo?.materialName || '')

                // 初始渲染
                renderTree()
            } else {

            }
        }).catch((error)=> console.log(error))
    }

    //输出单个父节点html
    function sinParentNodeHtml(nodeObj) {
        var jcHtml = "";
        if (nodeObj.isInherit == 1) {
            jcHtml = `<span class="jc" title="继承">
                                <svg class="icon" aria-hidden="true"><use xlink:href="#icon-process"></use></svg>
                            </span>`
        }
        var parentNodeHtml = `
                    <div class="parent-node parent-color${nodeObj.status}" data-id="${nodeObj.id}">
                        <div class="parent-header">
                            <div class="parent-title" title="${nodeObj.craftName}">${nodeObj.craftName}</div>
                            ${jcHtml}
                            <div class="node-actions">
                                <span class="btn btn-add add-child" title="新增">
                                    <svg class="icon" aria-hidden="true"><use xlink:href="#icon-add-select"></use></svg>
                                </span>
                                <span class="btn btn-edit edit-parent" title="编辑">
                                    <svg class="icon" aria-hidden="true"><use xlink:href="#icon-editor"></use></svg>
                                </span>
                                <span class="btn btn-delete delete-parent" title="删除">
                                    <svg class="icon" aria-hidden="true"><use xlink:href="#icon-ashbin-fill"></use></svg>
                                </span>
                            </div>
                            <span class="jt"></span>
                        </div>
                        <div class="child-container"></div>
                    </div>
                `
        return parentNodeHtml;
    }

    //输出单个子节点html
    function sinChildNodeHtml(nodeObj) {
        var jcHtml = "";
        if (nodeObj?.isInherit == 1) {
            jcHtml = `<span class="child-jc" title="继承">
                                <svg class="icon" aria-hidden="true"><use xlink:href="#icon-process"></use></svg>
                            </span>`
        }

        // 确认节点
        var confirmIconHtml = "";
        if(nodeObj.isConfirmNode === 1 & nodeObj.isConfirmType === 'F') {
            confirmIconHtml = `<span class="child-confirm-icon icon-F">F</span>`
        }
        if(nodeObj.isConfirmNode === 1 & nodeObj.isConfirmType === 'D') {
            confirmIconHtml = `<span class="child-confirm-icon icon-D">D</span>`
        }
        if(nodeObj.isConfirmNode === 1 & nodeObj.isConfirmType === 'M') {
            confirmIconHtml = `<span class="child-confirm-icon icon-M">M</span>`
        }
        
        var childNodeHtml = `
                    <div class="child-node child-color${nodeObj.status} ${nodeObj.isConfirmNode === 1 ? 'child-confirm-node':''}" data-id="${nodeObj.id}">
                        <div class="child-title">${nodeObj.processName}</div>
                        ${jcHtml}
                        <span class="node-type"><strong>进度：</strong><span>${nodeObj.doneCount === undefined ? '': nodeObj.doneCount}</span>/<span>${nodeObj.totalCount === undefined ? '' : nodeObj.totalCount}</span></span>
                        ${confirmIconHtml}
                        <div class="node-actions">
                            <span class="btn btn-edit edit-child" title="编辑">
                                <svg class="icon" aria-hidden="true"><use xlink:href="#icon-editor"></use></svg>
                            </span>
                            <span class="btn btn-delete delete-child" title="删除">
                                <svg class="icon" aria-hidden="true"><use xlink:href="#icon-ashbin-fill"></use></svg>
                            </span>
                        </div>
                    </div>
                `
        return childNodeHtml;
    }

    // 渲染流程树
    function renderTree() {
        $('#processTree').empty();
        processData.forEach((parent, index) => {
            const $parent = $(sinParentNodeHtml(parent));

            const $childContainer = $parent.find('.child-container');
            parent.children.forEach(child => {
                $childContainer.append(sinChildNodeHtml(child));
            });

            $('#processTree').append($parent);
            initSortable($childContainer);
        });

        // 初始化父节点排序
        $('#processTree').sortable({
            handle: '.parent-header',
            placeholder: 'ui-sortable-placeholder',
            axis: 'x',       // 禁用拖动时的透明度变化
            start: function (event, ui) {
                ui.item.find(".jt").hide();
                ui.item.addClass('dragging').css('transform', 'none');
            },
            stop: function (event, ui) {
                ui.item.find(".jt").show();
                ui.item.removeClass('dragging');
                ui.item.css({
                    "top": "inherit",
                    "left": "inherit",
                });
                const parentId = ui.item.data('id').toString()
                const parent = processData.find(p => p.id === parentId)
                const currentNodeOrderNo_new = processData.findIndex(p => p.id === parentId) + 1
                const currentNodeOrderNo_old = parent.orderNo // 接口父节点顺序从1开始
                if(currentNodeOrderNo_new !== currentNodeOrderNo_old) {
                    // 拖拽后执行保存并刷新数据
                    console.log('拖拽后===',)
                    const param = {
                        "id": parent.id,
                        "craftUUID": parent.craftUUID || '',
                        "orderNo_old": currentNodeOrderNo_old,
                        "orderNo_new": currentNodeOrderNo_new
                    }
                    apiUtil.saveDragProject(globalBaseInfo, JSON.stringify(param)).then((res)=>{
                        if(res.result === "ok") {
                            $.message.success(res.msg)
                        } else {
                            $.message.error(res.msg)
                        }
                        init()
                    }).catch((error)=> console.log(error))
                }
            },
            update: function () {
                const newOrder = $('#processTree').children().map((i, el) => {
                    return processData.find(p => p.id === $(el).data('id').toString());
                }).get();
                processData.length = 0;
                processData.push(...newOrder);
            }
        });
        $('.parent-node').eq(0).addClass('parent-active');
    }


    // 初始化子节点排序
    function initSortable($container) {
        $container.sortable({
            cursor: 'move',       // 拖动时显示移动光标
            tolerance: 'pointer', // 使用鼠标指针而不是元素边缘来确定位置
            opacity: 1.0,         // 禁用拖动时的透明度变化
            axis: 'y',
            helper: function (e, item) {
                // 创建一个自定义helper，保持原始宽度和水平居中
                const $helper = $(item).clone();
                const width = $(item).outerWidth();

                // 设置helper样式，确保水平居中
                $helper.css({
                    'width': width + 'px',
                    'margin-left': 'auto',
                    'margin-right': 'auto',
                    'left': 0,
                    'right': 0,
                    'box-shadow': '0 5px 15px rgba(0,0,0,0.2)'
                });

                return $helper;
            },
            start: function (event, ui) {
                // 禁用子节点的悬停效果，避免与拖拽产生视觉冲突
                ui.item.addClass('dragging').css('transform', 'none');
                // 保存原始位置信息
                const originalPosition = ui.helper.position();
                ui.item.data('originalPosition', originalPosition);

                // 添加拖拽中样式
                ui.item.addClass('dragging').css({
                    'transform': 'none',
                    'z-index': 80
                });
            },
            stop: function (event, ui) {
                // 恢复子节点的悬停效果
                ui.item.removeClass('dragging');

                // 获取父节点元素及相关信息
                const parentId = ui.item.closest('.parent-node').data('id').toString()
                const parent = processData.find(p => p.id === parentId)

                const childId = ui.item.data('id').toString()
                const childNode = parent.children.find(c => c.id === childId)
                const childNodeOrderNo_new = parent.children.findIndex(c => c.id === childId) + 1
                const childNodeOrderNo_old = childNode.orderNo // 接口父节点顺序从1开始
                if(childNodeOrderNo_new !== childNodeOrderNo_old) {
                    // 拖拽后执行保存并刷新数据
                    console.log('拖拽后===',)
                    const param = {
                        "parent_id": parent.id,
                        "parent_craftUUID": parent.craftUUID || '',
                        "child_id": childNode.id,
                        "child_kjjdCraftUUID": childNode.kjjdCraftUUID || '',
                        "child_orderNo_old": childNodeOrderNo_old,
                        "child_orderNo_new": childNodeOrderNo_new
                    }
                    apiUtil.saveDragELement(globalBaseInfo, JSON.stringify(param)).then((res)=>{
                        if(res.result === "ok") {
                            $.message.success(res.msg)
                        } else {
                            $.message.error(res.msg)
                        }
                        init()
                    }).catch((error)=> console.log(error))
                }
            },
            placeholder: 'ui-sortable-placeholder',
            update: function (event, ui) {
                const parentId = $(this).closest('.parent-node').data('id').toString();
                const parent = processData.find(p => p.id === parentId);
                parent.children = $(this).children().map((i, el) => {
                    return parent.children.find(c => c.id === $(el).data('id').toString());
                }).get();
            }
        });
    }

    // 添加父节点
    // $('#addParent').click(function () {
    //     const newId = Date.now();
    //     const newParent = {
    //         id: newId,
    //         status: 0,
    //         craftName: `新节点${newId}`,
    //         children: []
    //     };
    //     processData.push(newParent);
    //     $('#processTree').append(sinParentNodeHtml(newParent));
    // });

    // 添加节点弹窗里的tab
    $('#addNodeTabs').tabs({
        activate: function(event, ui) {
            currentAddNodeTabIndex = ui.newPanel.attr("id")
            console.log("当前是：",currentAddNodeTabIndex)
        },create: function(event, ui) {
        }
    })

    // 添加父节点按钮
    $('#addParent').click(function () {
        // 赋值当前操作是添加父节点
        currentAddNodeType = NODE_TYPE_PARENT
        
        apiUtil.getProjectData(globalBaseInfo).then((res)=> {
            if(res.result === "ok" && res.data) {
                projectList = res.data?.projectData

                $('#projectSelect').empty()
                var emptyProject = {id: '', craftName: '请选择工作项目'}// 待接口提供
                projectList.unshift(emptyProject)
                for(var i=0; i < projectList.length; i++ ) {
                    $('#projectSelect').append($('<option>', {
                        value: projectList[i].id,
                        text: projectList[i].craftName
                    }))
                }
            }
        }).catch((error)=> console.log(error))

        $('label[for="projectSelect"]').html('子阶段工作项目')
        $('label[for="newNodeName"]').html('子阶段名称')
        $('#projectSelect-error').hide()
        $('#newNodeName-error').hide()
        addNodeDialog.dialog("option","title", "添加子阶段")
        addNodeDialog.dialog("open")
    });

    // 添加子节点按钮
    $(document).on('click', '.add-child', function () {
        // 赋值当前操作是添加子节点
        currentAddNodeType = NODE_TYPE_CHILD
        
        // 获取父节点元素及相关信息
        const $parent = $(this).closest('.parent-node')
        const parentId = $parent.data('id').toString() // 转字符串
        const selectParentData = processData.find(p => p.id === parentId)

        // 保存待添加子节点的父节点
        pendingAddChildParent = selectParentData
        if(!pendingAddChildParent.children) {
            pendingAddChildParent.children = []
        }

        apiUtil.getElementData(globalBaseInfo, selectParentData).then((res)=> {
            if(res.result === "ok" && res.data) {
                elementList = res.data?.elementData

                $('#projectSelect').empty()
                var emptyElement = {id: '', processName: '请选择质量活动'}// 待接口提供
                elementList.unshift(emptyElement)
                for(var i=0; i < elementList.length; i++ ) {
                    $('#projectSelect').append($('<option>', {
                        value: elementList[i].id,
                        text: elementList[i].processName
                    }))
                }
            }
        }).catch((error)=> console.log(error))

        $('label[for="projectSelect"]').html('质量活动')
        $('label[for="newNodeName"]').html('活动名称')
        $('#projectSelect-error').hide()
        $('#newNodeName-error').hide()
        addNodeDialog.dialog("option","title", "添加质量活动")
        addNodeDialog.dialog("open")
    });
    
    // 添加节点-弹窗
    addNodeDialog = $( "#dialogAddNode" ).dialog({
      autoOpen: false,
      height: 400,
      width: 500,
      modal: true,
      title:'',
      buttons: {
        "保存": addNode,
        "取消": function() {
          addNodeDialog.dialog( "close" )
        }
      },
      close: function() {
        $('#newNodeName').val('')
        //form[ 0 ].reset()
        //allFields.removeClass( "ui-state-error" )
      }
    });

    // 添加节点-保存
    function addNode() {
        if(currentAddNodeTabIndex === 'tabs-project') {
            // 模型库选择
            let selectValue = $('#projectSelect').val()
            console.log('addNode', selectValue)
            if(selectValue) {
                if(currentAddNodeType === NODE_TYPE_PARENT) {
                    // 父节点工作项目
                    excuteAddProjectNodeToParent(selectValue)
                } else {
                    // 子节点工作要素
                    excuteAddElementNodeToChild(selectValue)
                }
            } else {
                let errerTip = ""
                if(currentAddNodeType === NODE_TYPE_PARENT) {
                    errerTip = "请选择工作项目"
                } else {
                    errerTip = "请选择工作要素"
                }
                $('#projectSelect-error').html(errerTip)
                $('#projectSelect-error').show()
            }
        } else {
            // 自定义
            let nodeName = $('#newNodeName').val()
            if(nodeName) {
                if(currentAddNodeType === NODE_TYPE_PARENT) {
                    // 父节点
                    excuteAddCustomNodeToParent(nodeName)
                } else {
                    // 子节点
                    excuteAddCustomNodeToChild(nodeName)
                }
            } else {
                let errerTip = ""
                if(currentAddNodeType === NODE_TYPE_PARENT) {
                    errerTip = "请输入子阶段名称"
                } else {
                    errerTip = "请输入活动名称"
                }
                $('#newNodeName-error').html(errerTip)
                $('#newNodeName-error').show()
            }
        }
       
    }

    // 添加节点成功后事件
    function afterNodeAdded() {

        addNodeDialog.dialog( "close" )

        if(currentAddNodeType === NODE_TYPE_PARENT) {
            // 滚动到最右边
            let $divBox = $(".processTreeBox")
            $divBox.animate({
                scrollLeft: $divBox[0].scrollWidth
            }, 500)
        }
        /* 
        if(currentAddNodeType === NODE_TYPE_CHILD) {
            // 滚动到最下边
            let $divBox = $(".processTreeBox")
            $divBox.animate({
                scrollTop: $divBox[0].scrollHeight
            }, 500)
        }*/
    }
    // 编辑节点成功后事件
    function afterNodeEdited() {
        editNodeDialog.dialog( "close" )
    }
    // 删除节点成功后事件
    function afterNodeDeleted() {
        deleteNodeDialog.dialog( "close" )
    }

    // 执行 添加节点-工作项目-父节点
    function excuteAddProjectNodeToParent(nodeValue) {
        if(!nodeValue) return

        const selectNode = projectList.find((item) => item["id"] === nodeValue )

        if(selectNode) {
            // TODO: 待接口返回该节点信息

            // 更新数据模型
            processData.push(selectNode)

            // 更新DOM
            $('#processTree').append(sinParentNodeHtml(selectNode))

            // 工作项目对象有工作要素子集时
            if(selectNode.children && selectNode.children.length > 0) {
                // 初始化新添加节点的子节点容器为可排序
                const $newParentNode = $(`.parent-node[data-id="${selectNode['id']}"]`)
                selectNode.children.forEach((childNode) => {
                    $newParentNode.find('.child-container').append(sinChildNodeHtml(childNode))
                })
                initSortable($newParentNode.find('.child-container'))
            }

            afterNodeAdded()
        }
    }
    // 执行 添加节点-工作要素-子节点
    function excuteAddElementNodeToChild(nodeValue) {
        if(!nodeValue) return

        const selectNode = elementList.find((item) => item["id"] === nodeValue )

        if(selectNode) {
            // TODO: 待接口返回该节点信息

            // 更新数据模型
            pendingAddChildParent.children.push(selectNode)

            // 更新DOM
            const $parentElement = $(`.parent-node[data-id="${pendingAddChildParent.id}"]`)
            $parentElement.find('.child-container').append(sinChildNodeHtml(selectNode))

            // 初始化子节点容器为可排序
            initSortable($parentElement.find('.child-container'))

            // 清除待添加子节点的父节点
            pendingAddChildParent = null 

            afterNodeAdded()
        }
    }
    // 执行 添加节点-自定义-父节点
    function excuteAddCustomNodeToParent(nodeName) {
        
        if (!nodeName) return

        // TODO: 待接口返回该节点信息

        const newId = Date.now() // 待接口提供
        const newParent = {
            id: newId.toString(),
            status: 0,
            craftName: nodeName,
            children: []
        };

        // 更新数据模型
        processData.push(newParent)

        // 更新DOM
        $('#processTree').append(sinParentNodeHtml(newParent))

        // 初始化新添加节点的子节点容器为可排序
        const $newParentNode = $(`.parent-node[data-id="${newId}"]`)
        initSortable($newParentNode.find('.child-container'))

        afterNodeAdded()
    }
    // 执行 添加节点-自定义-子节点
    function excuteAddCustomNodeToChild(nodeName) {

        if (!nodeName) return

        // TODO: 待接口返回该节点信息

        const newId = Date.now() // 待接口提供
        const newChild = {
            id: newId.toString(),
            status: 0,
            processName: nodeName,
            type: "未分类"
        }
        // 更新数据模型
        pendingAddChildParent.children.push(newChild)

        // 更新DOM
        const $parentElement = $(`.parent-node[data-id="${pendingAddChildParent.id}"]`)
        $parentElement.find('.child-container').append(sinChildNodeHtml(newChild))

        // 初始化子节点容器为可排序
        initSortable($parentElement.find('.child-container'))

        // 清除待添加子节点的父节点
        pendingAddChildParent = null 

        afterNodeAdded()
    }

    // 编辑节点-弹窗
    editNodeDialog = $( "#dialogEditNode" ).dialog({
      autoOpen: false,
      height: 200,
      width: 500,
      modal: true,
      title:'',
      buttons: {
        "保存": editNode,
        "取消": function() {
          editNodeDialog.dialog( "close" )
          currentEditingParent = null
          currentEditingChild = null
        }
      },
      close: function() {
        $('#editNodeName').val('')
      }
    });

    function editNode() {
        // 自定义
        let nodeName = $('#editNodeName').val()
        if(nodeName) {
            if(currentAddNodeType === NODE_TYPE_PARENT) {
                // 父节点
                excuteEditNodeToParent(nodeName)
            } else {
                // 子节点
                excuteEditNodeToChild(nodeName)
            }
        } else {
            let errerTip = ""
            if(currentAddNodeType === NODE_TYPE_PARENT) {
                errerTip = "请输入子阶段名称"
            } else {
                errerTip = "请输入活动名称"
            }
            $('#editNodeName-error').html(errerTip)
            $('#editNodeName-error').show()
        }
    }

    // 执行-编辑节点-父节点
    function excuteEditNodeToParent(nodeName) {
        if(!nodeName) return

        if (nodeName && currentEditingParent) {
            // 更新父节点标题
            currentEditingParent["craftName"] = nodeName

            // 重新渲染树
            // renderTree();

            // 直接更新DOM，找到对应的父节点并更新其标题内容
            const $parentNode = $(`.parent-node[data-id="${currentEditingParent.id}"]`)
            $parentNode.find('.parent-title').text(nodeName);
            
            afterNodeEdited()
        }
    }
    // 执行-编辑节点-子节点
    function excuteEditNodeToChild(nodeName) {
        if(!nodeName) return

        if (nodeName && currentEditingChild) {
            // 更新子节点数据
            currentEditingChild.processName = nodeName
            // currentEditingChild.type = newType

            // 重新渲染树
            // renderTree()
            // 直接更新DOM，找到对应的子节点并更新其内容
            const $childNode = $(`.child-node[data-id="${currentEditingChild.id}"]`)
            $childNode.find('.child-title').text(nodeName)
            
            afterNodeEdited()
        }
    }

    // 编辑父节点按钮事件
    $(document).on('click', '.edit-parent', function () {
        currentAddNodeType = NODE_TYPE_PARENT

        const $parent = $(this).closest('.parent-node')
        const parentId = $parent.data('id').toString() // 转字符串
        const parent = processData.find(p => p.id === parentId)

        // 保存当前编辑的父节点
        currentEditingParent = parent

        // 设置弹窗中的值 
        $('#editNodeName').val(parent["craftName"])

        $('label[for="editNodeName"]').html('子阶段名称')
        $('#editNodeName-error').hide()
        editNodeDialog.dialog("option","title", "编辑子阶段")
        editNodeDialog.dialog("open")
    });

    // 编辑子节点按钮事件
    $(document).on('click', '.edit-child', function () {
        currentAddNodeType = NODE_TYPE_CHILD

        const $child = $(this).closest('.child-node')
        const childId = $child.data('id').toString() // 转字符串
        const child = processData.flatMap(p => p.children).find(c => c.id === childId)

        // 保存当前编辑的子节点
        currentEditingChild = child

        // 设置弹窗中的值 
        $('#editNodeName').val(child["processName"])

        $('label[for="editNodeName"]').html('活动名称')
        $('#editNodeName-error').hide()
        editNodeDialog.dialog("option","title", "编辑质量活动")
        editNodeDialog.dialog("open")

        // 聚焦到标题输入框
        // setTimeout(() => {
        //     $('#editNodeName').focus()
        // }, 100)
    });

    // 删除节点-弹窗
    deleteNodeDialog = $( "#dialogDeleteNode" ).dialog({
      autoOpen: false,
      height: 230,
      width: 400,
      modal: true,
      title:'',
      buttons: {
        "确定": deleteNode,
        "取消": function() {
          deleteNodeDialog.dialog( "close" )
          pendingDeleteChild = null
          pendingDeleteParent = null
        }
      },
      close: function() {
      }
    });

    function deleteNode() {
        if(currentAddNodeType === NODE_TYPE_PARENT) {
            // 父节点
            excuteDeleteNodeToParent()
        } else {
            // 子节点
            excuteDeleteNodeToChild()
        }
    }

    // 执行-删除节点-父节点
    function excuteDeleteNodeToParent() {

        if (pendingDeleteParent) {
            // 从数据中删除
            const index = processData.findIndex(p => p.id === pendingDeleteParent.id)
            if (index !== -1) {
                processData.splice(index, 1)
            }

            // 从DOM中移除
            pendingDeleteParent.$element.remove()

            // 如果删除的是激活的节点，激活第一个节点
            if (pendingDeleteParent.$element.hasClass('parent-active') && processData.length > 0) {
                $('.parent-node').eq(0).addClass('parent-active')
            }

            pendingDeleteParent = null // 清除待删除的父节点信息
            
            afterNodeDeleted()
        }
    }
    // 执行-删除节点-子节点
    function excuteDeleteNodeToChild() {
        if (pendingDeleteChild) {
            // 从数据中删除
            processData.forEach(parent => {
                if(parent.children && parent.children.length > 0) {
                    parent.children = parent.children.filter(c => c.id !== pendingDeleteChild.id)
                }
            })

            // 从DOM中移除
            pendingDeleteChild.$element.remove()

            pendingDeleteChild = null; // 清除待删除的子节点信息

             afterNodeDeleted()
        }
    }

    // 删除父节点按钮事件
    $(document).on('click', '.delete-parent', function () {
        currentAddNodeType = NODE_TYPE_PARENT

        // 获取父节点元素及相关信息
        const $parent = $(this).closest('.parent-node')
        const parentId = $parent.data('id').toString() // 转字符串
        const parent = processData.find(p => p.id === parentId)

        // 保存待删除的父节点信息
        pendingDeleteParent = {
            $element: $parent,
            id: parentId
        };

        $('.deleteLabel').html('确定删除此子阶段及其所有质量活动吗？')
        deleteNodeDialog.dialog("option","title", "确认删除")
        deleteNodeDialog.dialog("open")
    })

    // 删除子节点按钮事件
    $(document).on('click', '.delete-child', function () {
        currentAddNodeType = NODE_TYPE_CHILD

        // 获取子节点元素及相关信息
        const $child = $(this).closest('.child-node')
        const childId = $child.data('id').toString() // 转字符串

        // 保存待删除的子节点信息
        pendingDeleteChild = {
            $element: $child,
            id: childId
        };

        $('.deleteLabel').html('确定删除此质量活动吗？')
        deleteNodeDialog.dialog("option","title", "确认删除")
        deleteNodeDialog.dialog("open")

        // 阻止事件冒泡，避免触发父节点的点击事件
        return false;
    });


    // // 关闭添加父节点弹窗
    // $(document).on('click', '#addParentModal .modal-close, #addParentModal .modal-cancel-btn', function () {
    //     $('#addParentModal').fadeOut(200);
    // });

    // // 点击添加父节点弹窗的遮罩层关闭弹窗
    // $(document).on('click', '#addParentModal', function (e) {
    //     if (e.target === this) {
    //         $('#addParentModal').fadeOut(200);
    //     }
    // });

    // 确认添加父节点
    // $(document).on('click', '#addParentModal .modal-confirm-btn', function () {
    //     // 获取新的父节点标题
    //     const newParentTitle = $('#newParentTitle').val().trim();

    //     if (newParentTitle) {
    //         const newId = Date.now();
    //         const newParent = {
    //             id: newId,
    //             status: 0,
    //             craftName: newParentTitle,
    //             children: []
    //         };

    //         // 更新数据模型
    //         processData.push(newParent);

    //         // 更新DOM
    //         $('#processTree').append(sinParentNodeHtml(newParent));

    //         // 初始化新添加节点的子节点容器为可排序
    //         const $newParentNode = $(`.parent-node[data-id="${newId}"]`);
    //         initSortable($newParentNode.find('.child-container'));

    //         // 关闭弹窗
    //         $('#addParentModal').fadeOut(200);
    //     }
    // });
    // 添加子节点
    // $(document).on('click', '.add-child', function () {
    //     const $parent = $(this).closest('.parent-node');
    //     const parentId = $parent.data('id');
    //     const parent = processData.find(p => p.id === parentId);
    //     const newId = Date.now();
    //     const newChild = {
    //         id: newId,
    //         status: 0,
    //         processName: `子节点${newId}`,
    //         type: "未分类"
    //     };
    //     parent.children.push(newChild);
    //     $parent.find('.child-container').append(sinChildNodeHtml(newChild));
    // });

    // 点击添加子节点按钮
    // $(document).on('click', '.add-child', function () {
    //     // 获取父节点元素及相关信息
    //     const $parent = $(this).closest('.parent-node');
    //     const parentId = $parent.data('id');
    //     const parent = processData.find(p => p.id === parentId);

    //     // 保存待添加子节点的父节点
    //     pendingAddChildParent = parent;

    //     // 清空输入框
    //     $('#newChildTitle').val('');

    //     // 显示弹窗
    //     $('#addChildModal').fadeIn(300);

    //     // 聚焦到输入框
    //     setTimeout(() => {
    //         $('#newChildTitle').focus();
    //     }, 100);
    // });

    // // 关闭添加子节点弹窗
    // $(document).on('click', '#addChildModal .modal-close, #addChildModal .modal-cancel-btn', function () {
    //     $('#addChildModal').fadeOut(200);
    //     pendingAddChildParent = null; // 清除待添加子节点的父节点
    // });

    // // 点击添加子节点弹窗的遮罩层关闭弹窗
    // $(document).on('click', '#addChildModal', function (e) {
    //     if (e.target === this) {
    //         $('#addChildModal').fadeOut(200);
    //         pendingAddChildParent = null; // 清除待添加子节点的父节点
    //     }
    // });

    // 确认添加子节点
    // $(document).on('click', '#addChildModal .modal-confirm-btn', function () {
    //     // 获取新的子节点标题
    //     const newChildTitle = $('#newChildTitle').val().trim();

    //     if (newChildTitle && pendingAddChildParent) {
    //         const newId = Date.now();
    //         const newChild = {
    //             id: newId,
    //             status: 0,
    //             processName: newChildTitle,
    //             type: "未分类"
    //         };

    //         // 更新数据模型
    //         pendingAddChildParent.children.push(newChild);

    //         // 更新DOM
    //         const $parentElement = $(`.parent-node[data-id="${pendingAddChildParent.id}"]`);
    //         $parentElement.find('.child-container').append(sinChildNodeHtml(newChild));

    //         // 关闭弹窗
    //         $('#addChildModal').fadeOut(200);
    //         pendingAddChildParent = null; // 清除待添加子节点的父节点
    //     }
    // });

    // 子节点悬浮框功能 - 优化箭头位置
    // 子节点悬浮框功能 - 修复 position-left 位置问题
    $(document).on('mouseenter', '.child-node', function (e) {
        const $child = $(this);
        const childId = $child.data('id').toString();
        const child = processData.flatMap(p => p.children).find(c => c.id === childId);

        if (child) {
            // 设置悬浮框内容
            const $tooltip = $('#childTooltip');
            $tooltip.find('.child-tooltip-title').text(child.processName);

            // 构建内容HTML
            let contentHtml = '';
            contentHtml += `<p><span class="label">活动类型:</span>${child.type || '未分类'}</p>`;

            // 可以根据你的数据模型添加更多信息
            if (child.description) {
                contentHtml += `<p><span class="label">活动描述:</span>${child.description}</p>`;
            }

            if (child.startDate) {
                contentHtml += `<p><span class="label">开始时间:</span>${child.startDate}</p>`;
            }
            if (child.orderNo) {
                contentHtml += `<p><span class="label">排序:</span>${child.orderNo}</p>`;
            }
            if (child.status !== undefined) {
                contentHtml += `<p><span class="label">状态:</span>${statusOptions[child.status]?.label}</p>`;
            }
            if (child.doneCount !== undefined) {
                contentHtml += `<p><span class="label">已完成数:</span>${child.doneCount}</p>`;
            }
            if (child.totalCount !== undefined) {
                contentHtml += `<p><span class="label">总数:</span>${child.totalCount}</p>`;
            }
            //  title: "技术状态更改",
            //         processName: "工作项目",
            //         orderNo: "顺序号",
            //         status: 0,
            //         doneCount: 1,
            //         totalCount: 10,
            $tooltip.find('.child-tooltip-content').html(contentHtml);
            // 重要：先重置所有可能影响大小的样式
            $tooltip.removeClass('position-right position-left position-top position-bottom')
                .css({
                    'max-width': '',  // 重置宽度限制
                    '--arrow-left': 'auto',
                    '--arrow-right': 'auto',
                    '--arrow-top': 'auto',
                    '--arrow-bottom': 'auto'
                });

            // 计算位置
            const childRect = $child[0].getBoundingClientRect();
            const childWidth = childRect.width;
            const childHeight = childRect.height;

            // 获取悬浮框的实际尺寸
            $tooltip.css('visibility', 'hidden').show();
            const tooltipWidth = $tooltip.outerWidth();
            const tooltipHeight = $tooltip.outerHeight();
            $tooltip.hide().css('visibility', '');

            // 计算可用空间
            const spaceRight = window.innerWidth - childRect.right - 40;
            const spaceLeft = childRect.left;

            let tooltipLeft, tooltipClass;

            // 在悬浮框定位代码中
            if (spaceRight >= tooltipWidth + 20) {
                // 右侧有足够空间，显示在右侧
                tooltipLeft = childRect.right + 10;
                tooltipClass = 'position-right';
            } else if (spaceLeft >= tooltipWidth + 20) {
                // 左侧有足够空间，显示在左侧
                tooltipLeft = childRect.left - tooltipWidth - 10;
                tooltipClass = 'position-left';
            } else {
                // 两侧都没有足够空间，选择空间较大的一侧
                if (spaceRight >= spaceLeft) {
                    tooltipLeft = childRect.right + 10;
                    tooltipClass = 'position-right';
                    // 移除这一行: $tooltip.css('max-width', (spaceRight - 20) + 'px');
                } else {
                    tooltipLeft = Math.max(10, childRect.left - Math.min(tooltipWidth, spaceLeft - 20));
                    tooltipClass = 'position-left';
                    // 移除这一行: $tooltip.css('max-width', (spaceLeft - 20) + 'px');
                }
            }

            // 计算垂直位置
            let tooltipTop = childRect.top + (childHeight / 2) - (tooltipHeight / 2);
            tooltipTop = Math.max(10, tooltipTop);
            tooltipTop = Math.min(window.innerHeight - tooltipHeight - 10, tooltipTop);

            // 添加类并设置位置
            $tooltip.addClass(tooltipClass)
                .css({
                    'left': tooltipLeft + 'px',
                    'top': tooltipTop + 'px',
                    '--arrow-left': tooltipClass === 'position-right' ? '-16px' : 'auto',
                    '--arrow-right': tooltipClass === 'position-left' ? '-16px' : 'auto',
                    '--arrow-top': '50%',
                    '--arrow-bottom': 'auto'
                })
                .stop(true, true)
                .fadeIn(200);
        }
    });

    // 鼠标离开子节点时隐藏悬浮框
    $(document).on('mouseleave', '.child-node', function () {
        $('#childTooltip').stop(true, true).fadeOut(100);
    });

    // 鼠标在悬浮框上时保持显示
    $(document).on('mouseenter', '#childTooltip', function () {
        $(this).stop(true, true).show();
    });

    // 鼠标离开悬浮框时隐藏
    $(document).on('mouseleave', '#childTooltip', function () {
        $(this).stop(true, true).fadeOut(100);
    });

    // // 关闭弹窗
    // $(document).on('click', '.modal-close, .modal-cancel-btn', function () {
    //     $('#editParentModal').fadeOut(200);
    // });

    // // 点击遮罩层关闭弹窗
    // $(document).on('click', '.modal-overlay', function (e) {
    //     if (e.target === this) {
    //         $('#editParentModal').fadeOut(200);
    //     }
    // });

    // 确认修改
    // $(document).on('click', '.modal-confirm-btn', function () {
    //     // 获取新的标题
    //     const newTitle = $('#parentTitle').val().trim();

    //     if (newTitle && currentEditingParent) {
    //         // 更新父节点标题
    //         currentEditingParent.craftName = newTitle;

    //         // 重新渲染树
    //         // renderTree();

    //         // 直接更新DOM，找到对应的父节点并更新其标题内容
    //         const $parentNode = $(`.parent-node[data-id="${currentEditingParent.id}"]`);
    //         $parentNode.find('.parent-title').text(newTitle);
    //         // 关闭弹窗
    //         $('#editParentModal').fadeOut(200);
    //     }
    // });


    // 编辑子节点 - 使用自定义弹窗
    // $(document).on('click', '.edit-child', function () {
    //     const $child = $(this).closest('.child-node');
    //     const childId = $child.data('id');
    //     const child = processData.flatMap(p => p.children).find(c => c.id === childId);

    //     // 保存当前编辑的子节点
    //     currentEditingChild = child;

    //     // 设置弹窗中的值
    //     $('#childTitle').val(child.processName);
    //     // $('#childType').val(child.type);

    //     // 显示弹窗
    //     $('#editChildModal').fadeIn(300);

    //     // 聚焦到标题输入框
    //     setTimeout(() => {
    //         $('#childTitle').focus();
    //     }, 100);
    // });

    // // 关闭子节点编辑弹窗
    // $(document).on('click', '#editChildModal .modal-close, #editChildModal .modal-cancel-btn', function () {
    //     $('#editChildModal').fadeOut(200);
    // });

    // // 点击子节点编辑弹窗遮罩层关闭弹窗
    // $(document).on('click', '#editChildModal', function (e) {
    //     if (e.target === this) {
    //         $('#editChildModal').fadeOut(200);
    //     }
    // });

    // 确认修改子节点
    // $(document).on('click', '#editChildModal .modal-confirm-btn', function () {
    //     // 获取新的标题和类型
    //     const newTitle = $('#childTitle').val().trim();
    //     // const newType = $('#childType').val().trim();

    //     if (newTitle && currentEditingChild) {
    //         // 更新子节点数据
    //         currentEditingChild.processName = newTitle;
    //         // currentEditingChild.type = newType;

    //         // 重新渲染树
    //         // renderTree();
    //         // 直接更新DOM，找到对应的子节点并更新其内容
    //         const $childNode = $(`.child-node[data-id="${currentEditingChild.id}"]`);
    //         $childNode.find('.child-title').text(newTitle);
    //         // 关闭弹窗
    //         $('#editChildModal').fadeOut(200);
    //     }
    // });

    // 添加键盘支持 - 在子节点编辑弹窗中按Enter确认，Esc取消
    // $(document).on('keydown', '#editChildModal', function (e) {
    //     if (e.key === 'Enter') {
    //         $('#editChildModal .modal-confirm-btn').click();
    //         e.preventDefault();
    //     } else if (e.key === 'Escape') {
    //         $('#editChildModal .modal-cancel-btn').click();
    //     }
    // });
    // 删除父节点
    // $(document).on('click', '.delete-parent', function () {
    //     if (confirm("确定删除此父节点及其所有子节点？")) {
    //         const $parent = $(this).closest('.parent-node');
    //         const parentId = $parent.data('id');
    //         const index = processData.findIndex(p => p.id === parentId);
    //         processData.splice(index, 1);
    //         $parent.remove();
    //     }
    // });
  
    // // 删除父节点 - 使用自定义弹窗
    // $(document).on('click', '.delete-parent', function () {
    //     // 获取父节点元素及相关信息
    //     const $parent = $(this).closest('.parent-node');
    //     const parentId = $parent.data('id');
    //     const parent = processData.find(p => p.id === parentId);

    //     // 保存待删除的父节点信息
    //     pendingDeleteParent = {
    //         $element: $parent,
    //         id: parentId
    //     };

    //     // 显示确认删除弹窗
    //     $('#deleteParentModal').fadeIn(300);
    // });

    // // 关闭删除确认弹窗
    // $(document).on('click', '#deleteParentModal .modal-close, #deleteParentModal .modal-cancel-btn', function () {
    //     $('#deleteParentModal').fadeOut(200);
    //     pendingDeleteParent = null; // 清除待删除的父节点信息
    // });

    // // 点击删除确认弹窗的遮罩层关闭弹窗
    // $(document).on('click', '#deleteParentModal', function (e) {
    //     if (e.target === this) {
    //         $('#deleteParentModal').fadeOut(200);
    //         pendingDeleteParent = null; // 清除待删除的父节点信息
    //     }
    // });

    // 确认删除父节点
    // $(document).on('click', '#deleteParentModal .modal-confirm-btn', function () {
    //     if (pendingDeleteParent) {
    //         // 从数据中删除
    //         const index = processData.findIndex(p => p.id === pendingDeleteParent.id);
    //         if (index !== -1) {
    //             processData.splice(index, 1);
    //         }

    //         // 从DOM中移除
    //         pendingDeleteParent.$element.remove();

    //         // 如果删除的是激活的节点，激活第一个节点
    //         if (pendingDeleteParent.$element.hasClass('parent-active') && processData.length > 0) {
    //             $('.parent-node').eq(0).addClass('parent-active');
    //         }

    //         // 关闭弹窗
    //         $('#deleteParentModal').fadeOut(200);
    //         pendingDeleteParent = null; // 清除待删除的父节点信息
    //     }
    // });
    // 删除子节点
    // $(document).on('click', '.delete-child', function () {
    //     if (confirm("确定删除此子节点？")) {
    //         const $child = $(this).closest('.child-node');
    //         const childId = $child.data('id');
    //         processData.forEach(parent => {
    //             parent.children = parent.children.filter(c => c.id !== childId);
    //         });
    //         $child.remove();
    //     }
    // });

    // 删除子节点 - 使用自定义弹窗
    // $(document).on('click', '.delete-child', function () {
    //     // 获取子节点元素及相关信息
    //     const $child = $(this).closest('.child-node');
    //     const childId = $child.data('id');

    //     // 保存待删除的子节点信息
    //     pendingDeleteChild = {
    //         $element: $child,
    //         id: childId
    //     };

    //     // 显示确认删除弹窗
    //     $('#deleteChildModal').fadeIn(300);

    //     // 阻止事件冒泡，避免触发父节点的点击事件
    //     return false;
    // });

    // // 关闭删除子节点确认弹窗
    // $(document).on('click', '#deleteChildModal .modal-close, #deleteChildModal .modal-cancel-btn', function () {
    //     $('#deleteChildModal').fadeOut(200);
    //     pendingDeleteChild = null; // 清除待删除的子节点信息
    // });

    // // 点击删除子节点确认弹窗的遮罩层关闭弹窗
    // $(document).on('click', '#deleteChildModal', function (e) {
    //     if (e.target === this) {
    //         $('#deleteChildModal').fadeOut(200);
    //         pendingDeleteChild = null; // 清除待删除的子节点信息
    //     }
    // });

    // 确认删除子节点
    // $(document).on('click', '#deleteChildModal .modal-confirm-btn', function () {
    //     if (pendingDeleteChild) {
    //         // 从数据中删除
    //         processData.forEach(parent => {
    //             if(parent.children && parent.children.length > 0) {
    //                 parent.children = parent.children.filter(c => c.id !== pendingDeleteChild.id);
    //             }
    //         });

    //         // 从DOM中移除
    //         pendingDeleteChild.$element.remove();

    //         // 关闭弹窗
    //         $('#deleteChildModal').fadeOut(200);
    //         pendingDeleteChild = null; // 清除待删除的子节点信息
    //     }
    // });
    // 显示全部节点状态；
    var nodeSwitchType = 1;//0是关 1是开
    // 开关显示节点
    $(".cw-switch").click(function () {
        //var index = $(".parent-node").index($(".parent-active"))
        if ($(this).hasClass('cw-switch-checked')) {
            nodeSwitchType = 0;
            $(".child-container").removeClass("child-con-show").addClass("child-con-hide");
            $(".parent-active").find(".child-container").removeClass("child-con-hide").addClass("child-con-show");
        } else {
            nodeSwitchType = 1;
            $(".child-container").removeClass("child-con-hide").addClass("child-con-show");
        }
        $(this).toggleClass('cw-switch-checked');

    });

    // 点击父节点
    $(document).on('click', '.parent-node .parent-header', function () {
        $(".parent-node").removeClass("parent-active");
        $(this).parent(".parent-node").addClass("parent-active");
        $(".child-container").removeClass("child-con-show");
        if (nodeSwitchType == 0) {
            $(".child-container").addClass("child-con-hide");
        }
        $(this).parent(".parent-node").find(".child-container").removeClass("child-con-hide").addClass("child-con-show");
    });

    // 自定义右侧抽屉弹窗
    const $drawerDialog = $('#drawer-dialog')
    const $drawerOverlay = $('#drawer-overlay')
    const $drawerIframe = $('#drawer-dialog .drawer-iframe')
    let isDrawerAnimating = false

    // 打开抽屉
    function openDrawer(srcUrl, title) {
        if (isDrawerAnimating) return

        isDrawerAnimating = true
        $drawerIframe.attr('src', srcUrl)
        $("#drawer-dialog #title").html(title)
        
        // 显示遮罩层
        $drawerOverlay.show()
        setTimeout(() => {
            $drawerOverlay.addClass('show')
        }, 10)
        
        // 显示抽屉
        $drawerDialog.show()
        setTimeout(() => {
            $drawerDialog.addClass('open')
            $drawerDialog.removeClass('closing')
        }, 10)
        
        // 动画完成后重置状态
        setTimeout(() => {
            isDrawerAnimating = false
        }, 400)
    }

    // 关闭抽屉
    function closeDrawer() {
        if (isDrawerAnimating) return
        
        isDrawerAnimating = true
        
        // 开始关闭动画
        $drawerDialog.removeClass('open')
        $drawerDialog.addClass('closing')
        $drawerOverlay.removeClass('show')
        $drawerOverlay.addClass('hiding')
        
        // 动画完成后隐藏元素
        setTimeout(() => {
            $drawerDialog.hide()
            $drawerOverlay.hide()
            $drawerIframe.attr('src', 'about:blank')
            $drawerDialog.removeClass('closing')
            $drawerOverlay.removeClass('hiding')
            isDrawerAnimating = false
        }, 400)
    }

    // 抽屉关闭确认框是否开启
    let closeConfirmFlag = false
    // 抽屉关闭按钮点击事件
    $('#drawer-dialog .drawer-close').on('click', function(e) {
        e.preventDefault()
        e.stopPropagation()

        if(!closeConfirmFlag) {
            // 确认框
            commonUtil.showConfirm({
                width: 300,
                message: '是否关闭?',
                onConfirm: function() {
                    closeDrawer()
                    closeConfirmFlag = false
                },
                onCancel: function() {
                    closeConfirmFlag = false
                }
            })
            closeConfirmFlag = true
        }
    });

    // 双击父节点(工作项目) 抽屉弹窗显示节点详情
    $(document).on('dblclick', '.parent-node .parent-header', function (event) {
        const $parent = $(this).closest('.parent-node')
        const parentId = $parent.data('id').toString() // 转字符串
        const parent = processData.find(p => p.id === parentId)
        
        // const extendParamObj = {
        //     "elementName" : globalBaseInfo?.materialName|| '',
        //     "extendProperties" : {
        //         "CRAFTNAME" : parent?.craftName|| '',
        //         "CRAFTCODE" : parent?.craftCode|| '',
        //         "DUTYPERSON" : parent?.dutyPerson || ''
        //     }
        // }
        const srcUrl = [
            detailUrl,
            `craftPathuuid=${craftPathUUID}`,//流程图工艺路线uuid
            `elementId=${parent.craftUUID || ''}`,//节点UUID
            // `extendParamJson=${JSON.stringify(extendParamObj)}`,
            // `lookBoardName=`,//节点的拓展信息
        ].join('&')
        openDrawer(srcUrl, parent?.craftName)
    });
    // 双击子节点(工作要素) 抽屉弹窗显示节点详情
    $(document).on('dblclick', '.child-node', function (event) {
        const $child = $(this)
        const childId = $child.data('id').toString() // 转字符串
        const child = processData.flatMap(p => p.children).find(c => c.id === childId)
        
        // const extendParamObj = {
        //     "elementName" : globalBaseInfo?.materialName|| '',
        //     "extendProperties" : {
        //         "CRAFTNAME" : child?.processName|| '',
        //         "CRAFTCODE" : child?.processCode|| '',
        //         "DUTYPERSON" : child?.dutyPerson || ''
        //     }
        // }
        const srcUrl = [
            detailUrl,
            `groupWorkId=${child.sid || ''}`, // 子节点 groupWorkId
            `craftPathuuid=${craftPathUUID}`,//流程图工艺路线uuid
            `elementId=${child.kjjdCraftUUID || ''}`,//节点UUID
            // `extendParamJson=${JSON.stringify(extendParamObj)}`,
            // `lookBoardName=`,//节点的拓展信息
        ].join('&')
        openDrawer(srcUrl, child?.processName)
    });

    // 点击【提交】
    $(document).on('click', '#saveProcess', function () {
        console.log('提交流程：', processData)
        apiUtil.saveProcessInfoData(globalBaseInfo, processData).then((res)=>{
            console.log(res)
            if(res.result === "ok") {
                $.message.success(res.msg)
            } else {
                $.message.error(res.msg)
            }
        }).catch((error)=> console.log(error))
    });

    // 点击【发布】
    $(document).on('click', '#savePublish', function () {
        // TODO: 待接口
    });
    // 点击【差异比对】
    $(document).on('click', '#patch', function () {
        const srcUrl = [
            compareUrl,
            `CRAFTPATHUUID=${craftPathUUID}`,//流程图工艺路线uuid
            `MATERIALUUID=${materialUUID}`,//模型唯一标识
            `CJBINDID=${parent.craftUUID || ''}`,//
        ].join('&')
        openDrawer(srcUrl, `${globalBaseInfo?.materialName}差异分析`)
    });

    // 滚动事件处理
    let isHeaderFixedShow = false
    $(".processTreeBox").on("scroll", function() {
        const scrollTop = $(this).scrollTop()
        const fixedHeader = $(".processHeaderFixed") // 父节点下面固定辅助区域
        const scrollThreshold = 10 // 滚动超过10px时显示顶部固定区域
        
        if (scrollTop > scrollThreshold) {
            // 向下滚动超过阈值时显示固定区域
            if (!isHeaderFixedShow) {
                fixedHeader.show()
                isHeaderFixedShow = true
            }
        } else {
            // 滚动到顶部附近时隐藏固定区域
            if (isHeaderFixedShow) {
                fixedHeader.hide()
                isHeaderFixedShow = false
            }
        }
    })
});
